OneToOneResolver.java

package org.codefilarete.stalactite.engine.configurer.resolver.onetoone;

import java.util.function.Consumer;

import org.codefilarete.reflection.ReadWritePropertyAccessPoint;
import org.codefilarete.stalactite.dsl.MappingConfigurationException;
import org.codefilarete.stalactite.dsl.property.CascadeOptions;
import org.codefilarete.stalactite.engine.configurer.manyToOne.ManyToOneOwnedBySourceConfigurer.MandatoryRelationAssertBeforeUpdateListener;
import org.codefilarete.stalactite.engine.configurer.model.ResolvedOneToOneRelation;
import org.codefilarete.stalactite.engine.configurer.onetoone.OneToOneConfigurerTemplate.MandatoryRelationAssertBeforeInsertListener;
import org.codefilarete.stalactite.engine.configurer.resolver.SkeletonAggregateResolver;
import org.codefilarete.stalactite.engine.runtime.ConfiguredRelationalPersister;
import org.codefilarete.stalactite.engine.runtime.onetoone.AbstractOneToOneEngine;
import org.codefilarete.stalactite.engine.runtime.onetoone.OneToOneOwnedBySourceEngine;
import org.codefilarete.stalactite.engine.runtime.onetoone.OneToOneOwnedByTargetEngine;
import org.codefilarete.stalactite.sql.ddl.structure.KeyMapping;
import org.codefilarete.stalactite.sql.ddl.structure.Table;

public class OneToOneResolver {
	
	private final SkeletonAggregateResolver skeletonAggregateResolver;
	
	public OneToOneResolver(SkeletonAggregateResolver skeletonAggregateResolver) {
		this.skeletonAggregateResolver = skeletonAggregateResolver;
	}
	
	/**
	 * Configure the given one-to-one relation by creating the persister for its target entity type and the engine that
	 * will maintain the cascades.
	 * It calls the given {@link Consumer} for the created target persister.
	 * 
	 * @param relationDefinition the one-to-one object that defines the relation to append
	 * @param sourcePersister the persister having the one-to-one relation
	 * @param createdPersisterConsumer a consumer to handle the created persister
	 * @param <SRC> type of the source entity
	 * @param <SRCID> type of the source entity's identifier
	 * @param <TRGT> type of the target entity
	 * @param <TRGTID> type of the target entity's identifier
	 * @param <LEFTTABLE> type of the left table in the one-to-one relation
	 * @param <RIGHTTABLE> type of the right table in the one-to-one relation
	 * @param <JOINID> type of the join identifier
	 */
	public <SRC, SRCID, TRGT, TRGTID, LEFTTABLE extends Table<LEFTTABLE>, RIGHTTABLE extends Table<RIGHTTABLE>, JOINID>
	void resolve(ResolvedOneToOneRelation<SRC, TRGT, LEFTTABLE, RIGHTTABLE, JOINID> relationDefinition,
	             ConfiguredRelationalPersister<SRC, SRCID> sourcePersister,
	             Consumer<ConfiguredRelationalPersister<TRGT, TRGTID>> createdPersisterConsumer) {
		
		assertConfigurationIsSupported(relationDefinition.getRelationMode());
		
		ConfiguredRelationalPersister<TRGT, TRGTID> targetPersister = skeletonAggregateResolver.buildPersister(relationDefinition.getTargetEntity());
		createdPersisterConsumer.accept(targetPersister);
		
		ReadWritePropertyAccessPoint<SRC, TRGT> targetAccessor = relationDefinition.getAccessor();
		KeyMapping<LEFTTABLE, RIGHTTABLE, JOINID> foreignKeyColumnsMapping = relationDefinition.getJoin().getLeftKey().reference(relationDefinition.getJoin().getRightKey());
		
		AbstractOneToOneEngine<SRC, TRGT, SRCID, TRGTID, LEFTTABLE, RIGHTTABLE> oneToOneEngine;
		if (relationDefinition.isOwnedByTarget()) {
			oneToOneEngine = new OneToOneOwnedByTargetEngine<>(sourcePersister, targetPersister, targetAccessor, foreignKeyColumnsMapping.getMapping());
		} else {
			oneToOneEngine = new OneToOneOwnedBySourceEngine<>(sourcePersister, targetPersister, targetAccessor, foreignKeyColumnsMapping.getMapping());
		}
		
		boolean orphanRemoval = relationDefinition.getRelationMode() == CascadeOptions.RelationMode.ALL_ORPHAN_REMOVAL;
		boolean writeAuthorized = relationDefinition.getRelationMode() != CascadeOptions.RelationMode.READ_ONLY;
		if (writeAuthorized) {
			// if cascade is mandatory, then adding nullability checking before insert
			if (relationDefinition.isMandatory()) {
				sourcePersister.addInsertListener(new MandatoryRelationAssertBeforeInsertListener<>(targetAccessor));
				sourcePersister.addUpdateListener(new MandatoryRelationAssertBeforeUpdateListener<>(targetAccessor));
			}
			
			oneToOneEngine.addInsertCascade();
			oneToOneEngine.addUpdateCascade(orphanRemoval);
			oneToOneEngine.addDeleteCascade(orphanRemoval);
		} else {
			// even if write is not authorized, we still have to insert and update source-to-target link, because we are in relation-owned-by-source
			if (!relationDefinition.isOwnedByTarget()) {
				((OneToOneOwnedBySourceEngine) oneToOneEngine).addForeignKeyMaintainer();
			}
		}
	}
	
	private void assertConfigurationIsSupported(CascadeOptions.RelationMode maintenanceMode) {
		if (maintenanceMode == CascadeOptions.RelationMode.ASSOCIATION_ONLY) {
			throw new MappingConfigurationException(CascadeOptions.RelationMode.ASSOCIATION_ONLY + " is only relevant for one-to-many association");
		}
	}
}